class BaseService {
    /**
     * @description 构造函数
     * @param {*} knex - knex实例
     * @param {*} model - 模型名称
     */
    constructor(knex, model='') {
        this.knex = knex;
        this.model = model;
    }

     /**
      * @description 查找所有符合条件的记录
      * @param {*} query - 查询条件，例如：{name: 'test', age: 18}
      * @returns {Promise} 返回符合条件的记录
      */
    query(query) {
        return this.knex(this.model).where(query);
    }

    /**
     * @description 查询表所有记录，慎用
     * @returns {Promise} 返回所有记录
     */
    all() {
        return this.knex(this.model).select();
    }

    /**
     * @description 查询指定id的记录
     * @param {*} id 
     * @returns {Promise} 返回指定id的记录
     */
    findById(id) {
        return this.knex(this.model).where('id', id).first();
    }

    /**
     * @description 查询分页数据
     * @param {*} current 
     * @param {*} pageSize 
     * @param {*} query 
     * @returns {Promise} 返回分页数据
     */
    async findListAndQuery(current = 1, pageSize = 10, query = {}) {
        const offset = (current - 1) * pageSize;

        let countQuery = this.knex(this.model).count('* as total');
        let dataQuery = this.knex(this.model);

        // 应用查询条件
        for (const key in query) {
            dataQuery = dataQuery.where(key, query[key]);
            countQuery = countQuery.where(key, query[key]);
        }

        // 获取总记录数
        const total = await countQuery.first();

        // 获取分页数据
        const data = await dataQuery.offset(offset).limit(pageSize);

        return { data, total: parseInt(total.total, 10) };
    }

    /**
     * @description 查询指定id的记录
     * @param {*} id - 记录id
     * @returns {Promise} 返回指定id的记录
     */
    findOneById(id) {
        return this.knex(this.model).where('id', id).select();
    }

    /**
     * @description 查询指定条件的记录
     * @param {Object} query - {<key>:<value>} 
     * @returns {Promise} 返回指定条件的记录
     */
    findOne(query) {
        return this.knex(this.model).where(query).first();
    }

    /**
     * @description 更新指定id的记录
     * @param {*} id - 记录id
     * @param {*} params - {<key>:<value>}
     * @returns {Promise} 返回更新后的记录
     */
    findOneAndUpdate(id, params) {
        return this.knex(this.model).where('id', id).update(params).returning('*');
    }


    /**
     * @description 查询指定条件的记录数量
     * @param {*} query - {<key>:<value>}
     * @returns {Promise} 返回指定条件的记录数量
     */
    count(query) {
        return this.knex(this.model).where(query).count('* as total').first();
    }

    /**
     * @description 插入一条记录
     * @param {*} params - {<key>:<value>}
     * @returns {Promise} 返回插入后的记录
     */
    insert(params) {
        return this.knex(this.model).insert(params);
    }

    /**
     * @description 插入多条记录
     * @param {*} records - [{<key>:<value>}, {<key>:<value>}, ...]
     * @returns {Promise} 返回插入后的记录
     */
    insertMany(records) {
        return this.knex(this.model).insert(records);
    }

    /**
     * @description 更新指定id的记录
     * @param {*} id - 记录id
     * @param {*} params - {<key>:<value>}
     * @returns {Promise} 返回更新后的记录
     */
    updateById(id, params) {
        return this.knex(this.model).where('id', id).update(params);
    }

    /**
     * @description 更新数据
     * @param {*} query - {<key>:<value>}
     * @param {*} update - {<key>:<value>}
     * @returns {Promise<*>} - 返回更新后的数据
     */
    update(query, update) {
        return this.knex(this.model).where(query).update(update);
    }

    /**
     * @description 查询并更新
     * @param {*} query - {<key>:<value>}
     * @param {*} update - {<key>:<value>}
     * @returns {Promise<*>} - 返回更新后的记录
     */
    findAndModify(query, update) {
        return this.knex(this.model).where(query).update(update);
    }

    /**
     * 
     * @param {*} id - id
     * @param {*} update - {<key>:<value>}
     * @returns {Promise<*>} - 返回更新后的记录
     */
    findByIdAndUpdate(id, update) {
        return this.knex(this.model).where('id', id).update(update);
    }

    /**
     * @description 根据条件更新记录
     * @param {*} query - {<key>:<value>}
     * @param {*} update - {<key>:<value>}
     * @returns {Promise} - 返回更新后的记录
     */
    findOneAndUpdate(query, update) {
        return this.knex(this.model).where(query).update(update);
    }

    /**
     * @description 根据id删除一条记录
     * @param {*} id - 记录id
     * @returns {Promise} - 返回删除的记录
     */
    findByIdAndRemove(id) {
        return this.knex(this.model).where('id', id).del();
    }

    /**
     * @description 根据条件删除一条记录
     * @param {*} query 
     * @returns {Promise} - 返回删除的记录
     */
    findOneAndRemove(query) {
        return this.knex(this.model).where(query).del();
    }
}

const Service = (knex, model='') => {
    return new BaseService(knex, model);
};

module.exports = Service;